home *** CD-ROM | disk | FTP | other *** search
/ TOS Silver 2000 / TOS Silver 2000.iso / Anwendun / 7UP_PD / FINDREP6.C < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-17  |  46.4 KB  |  1,974 lines
  1. /* Suchen und Ersetzen. Man beachte die for-Schleife in Z.815  */
  2. /*****************************************************************************
  3. *
  4. *                                              7UP
  5. *                                        Modul: FINDREP.C
  6. *                                     (c) by TheoSoft '90
  7. *
  8. *****************************************************************************/
  9. #include <portab.h>
  10. #include <stdio.h>
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include <time.h>
  14. #include <ctype.h>
  15. #include <aes.h>
  16. #include <vdi.h>
  17.  
  18. #include "alert.h"
  19. #include "windows.h"
  20. #include "forms.h"
  21. #include "7UP.h"
  22.  
  23. #include "language.h"
  24.  
  25. #define POSITION_OFFSET (wp->hwork/wp->hscroll/4)
  26. #define FSTRLEN            60
  27.  
  28. int adjust_best_position(WINDOW *wp); /* eventuell unten anpassen */
  29. refresh(WINDOW *wp, LINESTRUCT *line, int col, int row);
  30. char *match(char *first, char *what, char *how, int *len, char all, char one);
  31. char *imatch(char *first, char *what, char *how, int *len, char all, char one);
  32. char *grep(char *, char *, int *);
  33. char *igrep(char *, char *, int *);
  34.  
  35. typedef struct
  36. {
  37.     int menu,item;
  38. } UNDO;
  39.  
  40. extern UNDO undo;
  41.  
  42. extern OBJECT *findmenu,*replmenu,*gotomenu;
  43. extern char alertstr[];
  44. extern LINESTRUCT *lastwstr;
  45. extern long begline,endline,lasthfirst;
  46. extern int vdihandle,cut,or,kz,zz,fz,ur;
  47.  
  48. char searchstring[STRING_LENGTH+1];
  49.  
  50. void redraw(register WINDOW *wp, register LINESTRUCT *line, register long i, int replace)
  51. {
  52.     LINESTRUCT *help;
  53.     int found=FALSE,pxy[4];
  54.     long h,k,offset;
  55.  
  56.     graf_mouse(M_OFF,NULL);
  57.  
  58.     offset=POSITION_OFFSET;
  59.     if(wp->hsize>wp->hwork)
  60.     {
  61.         h=wp->hfirst;
  62.         for(k=0, help=wp->wstr; help && k<wp->hwork/wp->hscroll; k++, help=help->next)
  63.         {
  64.             if(help==line)
  65.             {
  66.                 found=TRUE;
  67.                 break;
  68.             }
  69.         }
  70.         if(found)
  71.         {
  72.             wp->cstr=line;
  73.         }
  74.         else
  75.         {
  76.             help=wp->fstr;  /* retten */
  77.             wp->cstr=wp->wstr=wp->fstr;
  78.             for(line=wp->fstr, k=0; k<i; line=line->next,k++)
  79.             {
  80.                 wp->wstr=wp->wstr->next;
  81.                 wp->cstr=wp->cstr->next;
  82.             }
  83.             for(k=0; k<offset && wp->wstr->prev; k++, i--, wp->wstr=wp->wstr->prev)
  84.                 ;
  85.             wp->fstr=help;                      /* wieder herstellen */
  86.             wp->hfirst = i * wp->hscroll;  /* anfang setzen */
  87.             adjust_best_position(wp);        /* eventuell unten anpassen */
  88.         }
  89.         wp->row=0;
  90.         for(line=wp->wstr; line!=wp->cstr; line=line->next)
  91.             wp->row++;
  92.  
  93.         if(replace)
  94.         {
  95.             if(h==wp->hfirst)
  96.             {
  97.                 for(line=wp->wstr, i=0; line!=wp->cstr; line=line->next, i++)
  98.                     ;
  99.                 pxy[0]=wp->xwork;
  100.                 pxy[1]=wp->ywork+i*wp->hscroll;
  101.                 pxy[2]=wp->wwork;
  102.                 pxy[3]=wp->hscroll;
  103.             }
  104.             else
  105.             {
  106.                 pxy[0]=wp->xwork;
  107.                 pxy[1]=wp->ywork;
  108.                 pxy[2]=wp->wwork;
  109.                 pxy[3]=wp->hwork;
  110.             }
  111.             Wredraw(wp,pxy);
  112.         }
  113.         else
  114.         {
  115.             if(h!=wp->hfirst)    /* redraw nötig? */
  116.             {
  117.                 pxy[0]=wp->xwork;
  118.                 pxy[1]=wp->ywork;
  119.                 pxy[2]=wp->wwork;
  120.                 pxy[3]=wp->hwork;
  121.                 Wredraw(wp,pxy);
  122.             }
  123.         }
  124.     }
  125.     else
  126.     {
  127.         wp->cstr=wp->fstr;
  128.         wp->row=0;
  129.         for(k=0; k<i; k++)
  130.         {
  131.             wp->cstr=wp->cstr->next;
  132.             wp->row++;
  133.         }
  134.         if(replace)
  135.         {
  136.             pxy[0]=wp->xwork;
  137.             pxy[1]=wp->ywork+i*wp->hscroll;
  138.             pxy[2]=wp->wwork;
  139.             pxy[3]=wp->hscroll;
  140.             Wredraw(wp,pxy);
  141.         }
  142.     }
  143.     Wslupdate(wp,1+2+4+8);
  144.     graf_mouse(M_ON,NULL);
  145. }
  146.  
  147. static int repl_string(LINESTRUCT *line, int index, int findstrlen, char *replstr, int replstrlen, int replall)
  148. {
  149.     char save;
  150.     char *sp;
  151.     char *help;
  152.     int newlen;
  153.  
  154.     if(replstrlen==0)
  155.     {
  156.         strcpy(&line->string[index],&line->string[index+findstrlen]);
  157.         line->used-=findstrlen;
  158.         return(index);
  159.     }
  160.     if(replstrlen<findstrlen)
  161.     {
  162.         memmove(&line->string[index],replstr,replstrlen);
  163.         strcpy(&line->string[index+replstrlen],&line->string[index+findstrlen]);
  164.         line->used-=(findstrlen-replstrlen);
  165.         return(index);
  166.     }
  167.     if(replstrlen==findstrlen)
  168.     {
  169.         if(replstrlen==1)
  170.             line->string[index]=*replstr;
  171.         else
  172.             memmove(&line->string[index],replstr,replstrlen);
  173.         return(index);
  174.     }
  175.     newlen=line->used+(replstrlen-findstrlen);
  176.     if(!(newlen<line->len))
  177.     {
  178.         if(!(newlen<STRING_LENGTH))
  179.             return(-1);
  180.         if((help=realloc(line->string,newlen+1)) == NULL)
  181.             return(-2);                                             /* Fehler! */
  182.         else
  183.         {
  184.             line->string=help;
  185.             line->len=newlen;
  186.         }
  187.     }
  188.     memmove(&line->string[index+replstrlen],
  189.               &line->string[index+findstrlen],
  190.               strlen(&line->string[index+findstrlen])+1);/*NULLBYTE*/
  191.     memmove(&line->string[index],replstr,replstrlen);
  192.     line->used=newlen;
  193.     return(index);
  194. }
  195.  
  196. int __isupper(char c)
  197. {
  198.     switch(c)
  199.     {
  200.         case 'Ä':
  201.         case 'Ö':
  202.         case 'Ü':
  203.             return(TRUE);
  204.         default:
  205.             return(isupper(c));
  206.     }
  207. }
  208.  
  209. int __islower(char c)
  210. {
  211.     switch(c)
  212.     {
  213.         case 'ä':
  214.         case 'ö':
  215.         case 'ü':
  216.             return(TRUE);
  217.         default:
  218.             return(islower(c));
  219.     }
  220. }
  221.  
  222. int __toupper(int c)
  223. {
  224.     switch(c)
  225.     {
  226.         case 'ä':
  227.         case 'Ä':
  228.             return('Ä');
  229.         case 'ö':
  230.         case 'Ö':
  231.             return('Ö');
  232.         case 'ü':
  233.         case 'Ü':
  234.             return('Ü');
  235.         default:
  236.             return(toupper(c));
  237.     }
  238. }
  239.  
  240. int __tolower(int c)
  241. {
  242.     switch(c)
  243.     {
  244.         case 'ä':
  245.         case 'Ä':
  246.             return('ä');
  247.         case 'ö':
  248.         case 'Ö':
  249.             return('ö');
  250.         case 'ü':
  251.         case 'Ü':
  252.             return('ü');
  253.         default:
  254.             return(tolower(c));
  255.     }
  256. }
  257.  
  258. int __strnicmp(char *s1, char *s2, int n)
  259. {
  260.     while((__toupper(*s1++) == __toupper(*s2++)) && --n)
  261.         ;
  262.     return(n);
  263. }
  264.  
  265. char *stristr(char *s1, char *s2)
  266. {
  267.     register int m;
  268.  
  269.     if(!*s1 || !*s2)
  270.         return(NULL);
  271.  
  272.     m=strlen(s2);
  273.     do
  274.     {
  275.         if(!__strnicmp(s1,s2,m))
  276.             return(s1);
  277.         s1++;
  278.     }
  279.     while(*s1);
  280.     return(NULL);
  281. }
  282.  
  283. char *strristr(char *s1, int index, char *s2, register int m)
  284. {
  285.     register int i,k;
  286.     for(i=index,k=1; i>=0; i--,k++)
  287.     {
  288.         if(!__strnicmp(&s1[i],s2,m)) /* min(k,m) */
  289.             return(&s1[i]);
  290.     }
  291.     return(NULL);
  292. }
  293.  
  294. char *strrstr(char *s1, int index, const char *s2, register int m)
  295. {
  296.     register int i,k;
  297.     for(i=index,k=1; i>=0; i--,k++)
  298.     {
  299.         if(!strncmp(&s1[i],s2,m)) /* min(k,m) */
  300.             return(&s1[i]);
  301.     }
  302.     return(NULL);
  303. }
  304.  
  305. int matchlen(char *str, char all) /* Länge des matchpattern */
  306. {                                            /* Beispiel: "*n*w?r*"     */
  307.     char *cp1,*cp2;                     /*                ^ ^    ^      */
  308.     register int i,k;                  /*                | Länge = 3 */
  309.                                              /* Dieser STAR ist uninteressant */
  310.     k=strlen(str);
  311.     cp1=str;                              /* Anfang */
  312.     cp2=&str[k-1];                      /* Ende    */
  313.     for(i=k-2; i>=0; i--)             /* Letzter STAR */
  314.         if(str[i]==all)
  315.         {
  316.             cp1=&str[i];
  317.             break;
  318.         }
  319.     for(i=0, cp1; cp1 != cp2+1L; cp1++)
  320.         if(*cp1 != all)
  321.             i++;
  322.     return(i);                /* Differenz = Länge */
  323. }
  324.  
  325. int greplen(char *str)
  326. {
  327.     return(1);
  328. }
  329.  
  330. void dialog_positionieren(WINDOW *wp, OBJECT *tree)
  331. {
  332.    int diff, ret;
  333.    GRECT t1, t2;
  334.     
  335.     form_center(tree,&ret,&ret,&ret,&ret);
  336.  
  337.     memmove(&t1, &tree->ob_x, sizeof(GRECT));
  338.     t1.g_x -= 3; 
  339.     t1.g_y -= 3; 
  340.     t1.g_w += 6;
  341.     t1.g_h += 6;
  342.     t2.g_x = wp->xwork+wp->col*wp->wscroll;
  343.     t2.g_y = wp->ywork+wp->row*wp->hscroll;
  344.     t2.g_w = wp->wscroll;
  345.     t2.g_h = wp->hscroll;
  346.     
  347.     if(rc_intersect(&t1, &t2))
  348.     {
  349.       if((t2.g_y + t2.g_h/2) < (t1.g_y + t1.g_h/2)) 
  350.             tree->ob_y += ((t2.g_y + t2.g_h - t1.g_y) + wp->hscroll);    /* Dialog tiefer setzen */
  351.         else
  352.             tree->ob_y -= ((t1.g_y + t1.g_h - t2.g_y) + wp->hscroll);
  353.     }
  354. }
  355.  
  356. static int msgbuf[8];
  357. static MEVENT mevent=
  358. {
  359.     MU_MESAG|MU_TIMER,
  360.     2,1,1,
  361.     0,0,0,0,0,
  362.     0,0,0,0,0,
  363.     msgbuf,
  364.     250L,
  365.     0,0,0,0,0,0,
  366. /* nur der Vollständigkeit halber die Variablen von XGEM */
  367.     0,0,0,0,0,
  368.     0,
  369.     0L,
  370.     0L,0L
  371. };
  372.  
  373. int hndl_find(WINDOW *wp, LINESTRUCT **begcut, LINESTRUCT **endcut, int item)
  374. {
  375.     static long zeile=0;                         /* wiedereintrittsfester Zähler */
  376.     static LINESTRUCT *line=0L;
  377.     static WINDOW *oldwp=0L;
  378.     static long oldsize=0L;
  379.     static int index=0;
  380.  
  381.     LINESTRUCT *help;
  382.     register long k,count=0;
  383.     int kshift,ret,ask=FALSE,done=FALSE,exit_obj,normal=FALSE,
  384.          matched=FALSE,greped=FALSE,
  385.          replace=FALSE,inblk=FALSE,replall=FALSE,ignore=FALSE;
  386.     int findstrlen,replstrlen,forward=TRUE;
  387.     char *sp,one,all,*grepcp=NULL;
  388.     char findstr[FSTRLEN+3],replstr[FSTRLEN+3];
  389.     int y,pxy[4];
  390.     int a,b,c,d,e,f,g,h,i,j,l,m,n;
  391.  
  392.     if(wp)
  393.     {
  394.  
  395.         findmenu[FINDFORW-2].ob_flags|=HIDETREE; /* Richung */
  396.  
  397.         k=wp->hsize/wp->hscroll;
  398.         if(!line || oldwp != wp || oldsize != k || item==SEARFIND)
  399.         {  /* alles auf NULL, wenn anderes Fenster oder neues Suchen */
  400.             index=0;
  401.             oldwp=wp;
  402.             oldsize=k;
  403.         }
  404.  
  405.         /* wo steht der Cursor jetzt */
  406.         line =wp->cstr;
  407.         zeile=wp->row+wp->hfirst/wp->hscroll;
  408.         index=wp->col+wp->wfirst/wp->wscroll;
  409.  
  410.         if(item == SEARFIND)                              /* FIND/REPLACE */
  411.         {
  412.             if((!(*begcut) && !(*endcut)) ||
  413.                 ( (*begcut) && !(*endcut)) || /* offenes Blockende */
  414.                 (!(*begcut) &&  (*endcut)))    /* offener Blockanfang */
  415. /*
  416.             if(!(*begcut) && !(*endcut))
  417. */
  418.             {
  419.                 findmenu[FINDBLK].ob_state &=~SELECTED;
  420.                 findmenu[FINDBLK].ob_state |= DISABLED;
  421.             }
  422.             if((*begcut) && (*endcut) && (*begcut)==(*endcut))
  423.             {
  424.                 findmenu[FINDBLK].ob_state &=~DISABLED;
  425.                 findmenu[FINDBLK].ob_state &=~SELECTED;
  426.             }
  427.             if((*begcut) && (*endcut) && (*begcut)!=(*endcut))
  428.             {
  429.                 findmenu[FINDBLK].ob_state &=~DISABLED;
  430.                 findmenu[FINDBLK].ob_state |= SELECTED;
  431.             }
  432.                                         /* Es soll im Block gesucht werden */
  433.                                         /*                    ||                     */
  434.             if((*begcut) && (*endcut) && (*begcut)==(*endcut) && (*endcut)->begcol<(*endcut)->used)
  435.             {
  436.                 strncpy(searchstring,&(*begcut)->string[(*begcut)->begcol],(*begcut)->endcol-(*begcut)->begcol);
  437.                 searchstring[(*begcut)->endcol-(*begcut)->begcol]=0;
  438.                 searchstring[findmenu[FINDSTR].ob_spec.tedinfo->te_txtlen-1]=0;
  439.             }
  440.             if(*searchstring && !matched && !greped) /* nur dann! */
  441.             {
  442.                 form_write(findmenu,FINDSTR,searchstring,FALSE);
  443.                 form_write(findmenu,FINDREPL,searchstring,FALSE);
  444.             }
  445.             a=findmenu[FINDMAT ].ob_state; /* Objektstati für ABBRUCH merken */
  446.             b=findmenu[FINDNORM].ob_state;
  447.             c=findmenu[FINDGREP].ob_state;
  448.             d=findmenu[FINDSUCH].ob_state;
  449.             e=findmenu[FINDERS ].ob_state;
  450.             f=findmenu[FINDBLK ].ob_state;
  451.             g=findmenu[FINDANF ].ob_state;
  452.             h=findmenu[FINDASK ].ob_state;
  453.             i=findmenu[FINDALL ].ob_state;
  454.             j=findmenu[FINDIGNO].ob_state;
  455.             l=findmenu[FINDWORD].ob_state;
  456.             m=findmenu[FINDFORW].ob_state;
  457.             n=findmenu[FINDBACK].ob_state;
  458.             form_exopen(findmenu,0);
  459.             do
  460.             {
  461.                 exit_obj=(form_exdo(findmenu,FINDSTR)&0x7FFF);
  462.                 switch(exit_obj)
  463.                 {
  464.                     case FINDFORW:
  465.                         findmenu[FINDGREP].ob_state &=~DISABLED;
  466.                         objc_update(findmenu,FINDGREP,0);
  467.                         findmenu[FINDMAT].ob_state &=~DISABLED;
  468.                         objc_update(findmenu,FINDMAT,0);
  469.                         findmenu[FINDANF].ob_state &=~DISABLED;
  470.                         objc_update(findmenu,FINDANF,0);
  471.                         break;
  472.                     case FINDBACK:
  473.                         findmenu[FINDNORM].ob_state |= SELECTED;
  474.                         objc_update(findmenu,FINDNORM,0);
  475.                         findmenu[FINDMAT].ob_state &=~SELECTED;
  476.                         findmenu[FINDMAT].ob_state |= DISABLED;
  477.                         objc_update(findmenu,FINDMAT,0);
  478.                         findmenu[FINDGREP].ob_state &=~SELECTED;
  479.                         findmenu[FINDGREP].ob_state |= DISABLED;
  480.                         objc_update(findmenu,FINDGREP,0);
  481.                         findmenu[FINDANF].ob_state &=~SELECTED;
  482.                         findmenu[FINDANF].ob_state |= DISABLED;
  483.                         objc_update(findmenu,FINDANF,0);
  484.                         break;
  485.                     case FINDMAT:
  486.                     case FINDGREP:
  487.                         findmenu[FINDFORW].ob_state |=SELECTED;
  488.                         objc_update(findmenu,FINDFORW,0);
  489.                         findmenu[FINDBACK].ob_state &=~SELECTED;
  490.                         findmenu[FINDBACK].ob_state |=DISABLED;
  491.                         objc_update(findmenu,FINDBACK,0);
  492.                         findmenu[FINDWORD].ob_state &=~SELECTED;
  493.                         findmenu[FINDWORD].ob_state |= DISABLED;
  494.                         objc_update(findmenu,FINDWORD,0);
  495.                         break;
  496.                     case FINDNORM:
  497.                         findmenu[FINDBACK].ob_state &=~DISABLED;
  498.                         objc_update(findmenu,FINDBACK,0);
  499.                         findmenu[FINDWORD].ob_state &=~DISABLED;
  500.                         objc_update(findmenu,FINDWORD,0);
  501.                         break;
  502.                     case FINDSUCH:
  503.                         if(findmenu[FINDNORM].ob_state & SELECTED)
  504.                         {
  505.                             findmenu[FINDWORD].ob_state &=~DISABLED;
  506.                             objc_update(findmenu,FINDWORD,0);
  507.                         }
  508.                         findmenu[FINDALL].ob_state&=~SELECTED;
  509.                         findmenu[FINDALL].ob_state|=DISABLED;
  510.                         objc_update(findmenu,FINDALL,0);
  511.                         findmenu[FINDASK].ob_state&=~SELECTED;
  512.                         findmenu[FINDASK].ob_state|=DISABLED;
  513.                         objc_update(findmenu,FINDASK,0);
  514.                         break;
  515.                     case FINDERS:
  516.                         if(findmenu[FINDNORM].ob_state & SELECTED)
  517.                         {  /* nicht bei match oder grep */
  518.                             findmenu[FINDWORD].ob_state &=~DISABLED;
  519.                             objc_update(findmenu,FINDWORD,0);
  520.                         }
  521.                         findmenu[FINDALL].ob_state&=~DISABLED;
  522.                         objc_update(findmenu,FINDALL,0);
  523.                         findmenu[FINDASK].ob_state&=~DISABLED;
  524.                         objc_update(findmenu,FINDASK,0);
  525.                         break;
  526.                     case FINDBLK:
  527.                         findmenu[FINDANF].ob_state&=~SELECTED;
  528.                         objc_update(findmenu,FINDANF,0);
  529.                         break;
  530.                     case FINDANF:
  531.                         line=wp->fstr;
  532.                         zeile=0;
  533.                         findmenu[FINDBLK].ob_state&=~SELECTED;
  534.                         objc_update(findmenu,FINDBLK,0);
  535.                         break;
  536.                     case FINDHELP:
  537.                         if(findmenu[FINDNORM].ob_state&SELECTED)
  538.                         {
  539.                             form_alert(1,Afindrep[0]);
  540.                         }
  541.                         if(findmenu[FINDMAT ].ob_state&SELECTED)
  542.                         {
  543.                             form_alert(1,Afindrep[1]);
  544.                         }
  545.                         if(findmenu[FINDGREP].ob_state&SELECTED)
  546.                         {
  547.                             if(form_alert(2,Afindrep[2])==2)
  548.                                 if(form_alert(2,Afindrep[3])==2)
  549.                                     form_alert(1,Afindrep[4]);
  550.                         }
  551.                         objc_change(findmenu,exit_obj,0,findmenu->ob_x,findmenu->ob_y,findmenu->ob_width,findmenu->ob_height,findmenu[exit_obj].ob_state&~SELECTED,TRUE);
  552.                         break;
  553.                     case FINDOK:
  554.                     case FINDABBR:
  555.                         done=TRUE;
  556.                         break;
  557.                 }
  558.             }
  559.             while(!done);
  560.             form_exclose(findmenu,exit_obj,0);
  561.             if(exit_obj==FINDABBR)
  562.             {
  563.                 findmenu[FINDMAT ].ob_state=a;
  564.                 findmenu[FINDNORM].ob_state=b;
  565.                 findmenu[FINDGREP].ob_state=c;
  566.                 findmenu[FINDSUCH].ob_state=d;
  567.                 findmenu[FINDERS ].ob_state=e;
  568.                 findmenu[FINDBLK ].ob_state=f;
  569.                 findmenu[FINDANF ].ob_state=g;
  570.                 findmenu[FINDASK ].ob_state=h;
  571.                 findmenu[FINDALL ].ob_state=i;
  572.                 findmenu[FINDIGNO].ob_state=j;
  573.                 findmenu[FINDWORD].ob_state=l;
  574.                 findmenu[FINDFORW].ob_state=m;
  575.                 findmenu[FINDBACK].ob_state=n;
  576.                 return(FALSE);
  577.             }
  578.         }
  579.         if(item==SEARNEXT || item==SEARSEL) /* WEITERSUCHEN */
  580.         {
  581.             if(findmenu[FINDBACK].ob_state & SELECTED) /* Richtung festlegen */
  582.             {
  583.                 index=wp->col+wp->wfirst/wp->wscroll-1;
  584.                 forward=FALSE;
  585.             }
  586.             else
  587.             {
  588.                 if(inblk) /* nur vorwärts */
  589.                     index=wp->col+wp->wfirst/wp->wscroll+1;
  590.                 forward=TRUE;
  591.             }
  592.  
  593.             graf_mkstate(&ret, &ret, &ret, &kshift);
  594.             if(kshift & (K_RSHIFT|K_LSHIFT)) /* Suchrichtungsumkehr */
  595.             {
  596.                 if(forward)
  597.                 {
  598.                     if((findmenu[FINDSUCH].ob_state & SELECTED) &&
  599.                         (findmenu[FINDNORM].ob_state & SELECTED))
  600.                     {
  601.                         findmenu[FINDFORW].ob_state &= ~SELECTED;
  602.                         findmenu[FINDBACK].ob_state |=  SELECTED;
  603.                         findmenu[FINDANF ].ob_state &= ~SELECTED;
  604.                         findmenu[FINDANF ].ob_state |=  DISABLED;
  605.                         forward=FALSE;
  606.                         index--;
  607.                     }
  608.                 }
  609.                 else
  610.                 {
  611.                     if((findmenu[FINDSUCH].ob_state & SELECTED) &&
  612.                         (findmenu[FINDNORM].ob_state & SELECTED))
  613.                     {
  614.                         findmenu[FINDBACK].ob_state &= ~SELECTED;
  615.                         findmenu[FINDFORW].ob_state |=  SELECTED;
  616.                         findmenu[FINDANF ].ob_state &= ~DISABLED;
  617.                         forward=TRUE;
  618.                         index++;
  619.                     }
  620.                 }
  621.             }
  622.             if(item!=SEARSEL)
  623.                 if(!(findmenu[FINDBLK].ob_state & SELECTED)) /* !inblk */
  624.                 {
  625.                     if(!cut)
  626.                         hide_blk(wp,*begcut,*endcut);
  627.                     else
  628.                         free_blk(wp,*begcut);
  629.                 }
  630.         }
  631.         if(item==SEARSEL)
  632.         {
  633.             findmenu[FINDNORM].ob_state = SELECTED; /* alles auf null für Find Selection */
  634.             findmenu[FINDMAT ].ob_state = NORMAL;
  635.             findmenu[FINDGREP].ob_state = NORMAL;
  636.  
  637.             findmenu[FINDSUCH].ob_state = SELECTED;
  638.             findmenu[FINDERS ].ob_state = NORMAL;
  639.  
  640.             findmenu[FINDBLK ].ob_state = NORMAL;
  641.  
  642.             findmenu[FINDANF ].ob_state = NORMAL;
  643.             findmenu[FINDASK ].ob_state = NORMAL;
  644.             findmenu[FINDALL ].ob_state = NORMAL;
  645.  
  646.             /* FINDWORD und FINDIGNO sind erlaubt, FINDFORW und FINDBACK auch */
  647.  
  648.             if((*begcut) && (*endcut) && (*begcut)==(*endcut) && (*endcut)->begcol<(*endcut)->used)
  649.             {    /* zurechtstutzen, auf korrekte Länge kürzen */
  650.                 strncpy(searchstring,&(*begcut)->string[(*begcut)->begcol],(*begcut)->endcol-(*begcut)->begcol);
  651.                 searchstring[(*begcut)->endcol-(*begcut)->begcol]=0;
  652.                 searchstring[findmenu[FINDSTR].ob_spec.tedinfo->te_txtlen-1]=0;
  653.             }
  654.             else
  655.             {
  656.                 Wdclickword(wp,begcut,endcut,wp->xwork+wp->col*wp->wscroll+1,wp->ywork+wp->row*wp->hscroll+1);
  657.             }
  658.             if(*searchstring) /* nur dann! */
  659.             {
  660.                 form_write(findmenu,FINDSTR,searchstring,FALSE);
  661.                 form_write(findmenu,FINDREPL,"",FALSE);
  662.             }
  663.         }
  664.  
  665.         form_read(findmenu,FINDSTR,findstr);              /* sonst NEXT */
  666.         form_read(findmenu,FINDREPL,replstr);
  667.  
  668.         if(!*findstr)            /* wenn nix zum Suchen da ist, beenden */
  669.         {
  670.             return(FALSE);
  671.         }
  672.  
  673.         if(findmenu[FINDERS].ob_state & SELECTED)
  674.         {
  675.             replace=TRUE;
  676.         }
  677.  
  678.         if(findmenu[FINDASK].ob_state & SELECTED)
  679.         {
  680.             ask=TRUE;
  681.         }
  682.  
  683.         if(findmenu[FINDALL].ob_state & SELECTED)
  684.         {
  685.             replall=TRUE;
  686.         }
  687.  
  688.         if(!(findmenu[FINDIGNO].ob_state & SELECTED))
  689.         {
  690.             ignore=TRUE;
  691.         }
  692.  
  693.         if(findmenu[FINDWORD].ob_state & SELECTED)
  694.         {  /* ein Blank vorn und hinten */
  695.             memmove(&findstr[1],findstr,strlen(findstr)+1);
  696.             findstr[0]=' ';
  697.             strcat(findstr," ");
  698.             memmove(&replstr[1],replstr,strlen(replstr)+1);
  699.             replstr[0]=' ';
  700.             strcat(replstr," ");
  701.         }
  702.  
  703.         if(findmenu[FINDNORM].ob_state & SELECTED)
  704.         {
  705.             findstrlen=strlen(findstr);
  706.             normal=TRUE;
  707.         }
  708.  
  709.         if(findmenu[FINDMAT].ob_state & SELECTED)
  710.         {
  711.             one= *findmenu[FINDSINQ].ob_spec.tedinfo->te_ptext;
  712.             all= *findmenu[FINDALLQ].ob_spec.tedinfo->te_ptext;
  713.             if(!one || !all)
  714.             {
  715.                 form_alert(1,Afindrep[5]);
  716.                 return(FALSE);
  717.             }
  718.             findstrlen=matchlen(findstr,all);
  719.             matched=TRUE;
  720.         }
  721.  
  722.         if(findmenu[FINDGREP].ob_state & SELECTED)
  723.         {
  724.             if(ignore)
  725.             {
  726.                 if(!icompile(findstr)) /* immer kompilieren !!! */
  727.                 {
  728.                     form_alert(1,Afindrep[6]);
  729.                     return(FALSE);
  730.                 }
  731.             }
  732.             else
  733.             {
  734.                 if(!compile(findstr)) /* immer kompilieren !!! */
  735.                 {
  736.                     form_alert(1,Afindrep[6]);
  737.                     return(FALSE);
  738.                 }
  739.             }
  740.             findstrlen=greplen(findstr);
  741.             greped=TRUE;
  742.         }
  743.  
  744.         if(findmenu[FINDANF].ob_state & SELECTED)
  745.         {
  746.             if(item==SEARFIND)
  747.             {
  748.                 line=wp->fstr;
  749.                 zeile=0;
  750.                 index=0;
  751.             }
  752.         }
  753.  
  754.         if(findmenu[FINDBACK].ob_state & SELECTED)
  755.         {
  756.             forward=FALSE;
  757.         }
  758.  
  759.         if(findmenu[FINDBLK].ob_state & SELECTED)
  760.         {
  761.             if((*begcut) && (*endcut))
  762.             {
  763.                 inblk=TRUE;
  764.                 if(item==SEARFIND)
  765.                 {
  766.                     if(forward)
  767.                     {
  768.                         for(zeile=0,line=wp->fstr;
  769.                              zeile<k && line!=(*begcut);
  770.                              zeile++,line=line->next)
  771.                             ;
  772.                         index=(*begcut)->begcol;    /* ab Blockbegin suchen */
  773.                     }
  774.                     else
  775.                     {
  776.                         for(zeile=0,line=wp->fstr;
  777.                              zeile<k && line!=(*endcut)/*->next*/;
  778.                              zeile++,line=line->next)
  779.                             ;
  780.                         index=min((*endcut)->used-1,(*endcut)->endcol-1);    /* ab Blockende suchen */
  781.                     }
  782.                 }
  783.             }
  784.         }
  785.         else
  786.         {
  787.             if(!cut)
  788.                 hide_blk(wp,*begcut,*endcut);
  789.             else
  790.                 free_blk(wp,*begcut);
  791.         }
  792.  
  793.         form_write(replmenu,REPLSTR,replstr,FALSE);
  794.         if(replace)
  795.             replstrlen=strlen(replstr);
  796.         else
  797.             replstrlen=0;
  798.  
  799.         graf_mouse(M_OFF,0L);
  800.         Wcursor(wp);         /* ausschalten */
  801.         if(item==SEARFIND) /* Dialogbox wegräumen */
  802.         {
  803.             evnt_event(&mevent); /* Dummyaufruf um Redraw zu killen */
  804.             Wredraw(wp,&msgbuf[4]);
  805.         }
  806.         graf_mouse(M_ON,0L);
  807. #if OLDTOS
  808.         if(!ask)
  809.             graf_mouse(BUSY_BEE,0L);
  810. #endif
  811.         do
  812.         {
  813.             if(forward)
  814.             {
  815.                 for(line, zeile;
  816.                      zeile<k && line && (inblk?line!=(*endcut)->next:1);     /* nur im Block wenn gewünscht */
  817.                      line=line->next, zeile++,
  818.                      index=(inblk?(line?line->begcol:0):0))
  819.                 {
  820.                     if(normal)
  821.                     {
  822.                         if(ignore)
  823.                         {      /* stristr() unterscheidet nicht zwischen GROβ und klein */
  824.                             if(sp=stristr(&line->string[index],findstr))
  825.                             {
  826.                                 if(inblk)
  827.                                 {
  828.                                     if((int)(sp - line->string)<=line->endcol)
  829.                                         break;
  830.                                 }
  831.                                 else
  832.                                     break;
  833.                             }
  834.                         }
  835.                         else
  836.                         {
  837.                             if(sp=strstr(&line->string[index],findstr))
  838.                             {
  839.                                 if(inblk)
  840.                                 {
  841.                                     if((int)(sp - line->string)<=line->endcol)
  842.                                         break;
  843.                                 }
  844.                                 else
  845.                                     break;
  846.                             }
  847.                         }
  848.                     }
  849.                     if(matched)
  850.                     {
  851.                         if(ignore)
  852.                         {
  853.                             if(sp=imatch(line->string,&line->string[index],findstr,&findstrlen,all,one))
  854.                             {
  855.                                 if(inblk)
  856.                                 {
  857.                                     if((int)(sp - line->string)<=line->endcol)
  858.                                         break;
  859.                                 }
  860.                                 else
  861.                                     break;
  862.                             }
  863.                         }
  864.                         else
  865.                         {
  866.                             if(sp=match(line->string,&line->string[index],findstr,&findstrlen,all,one))
  867.                             {
  868.                                 if(inblk)
  869.                                 {
  870.                                     if((int)(sp - line->string)<=line->endcol)
  871.                                         break;
  872.                                 }
  873.                                 else
  874.                                     break;
  875.                             }
  876.                         }
  877.                     }
  878.                     if(greped)
  879.                     {
  880.                         if(ignore)
  881.                         {
  882.                             if(sp=igrep(&line->string[index],&line->string[index],&findstrlen))
  883.                             {
  884.                                 if(inblk)
  885.                                 {
  886.                                     if((int)(sp - line->string)<=line->endcol)
  887.                                         break;
  888.                                 }
  889.                                 else
  890.                                     break;
  891.                             }
  892.                         }
  893.                         else
  894.                         {
  895.                             if(sp=grep(&line->string[index],&line->string[index],&findstrlen))
  896.                             {
  897.                                 if(inblk)
  898.                                 {
  899.                                     if((int)(sp - line->string)<=line->endcol)
  900.                                         break;
  901.                                 }
  902.                                 else
  903.                                     break;
  904.                             }
  905.                         }
  906.                     }
  907.                 }
  908.             }
  909.             else /* rückwärts suchen */
  910.             {
  911.                 for(line, zeile;
  912.                      zeile>=0 && line && (inblk?line!=(*begcut)->prev:1);     /* nur im Block wenn gewünscht */
  913.                      line=line->prev, zeile--,
  914.                      index=(inblk?(line?min(line->endcol-1,line->used-1):0):(line?line->used-1:0)))
  915.                 {
  916.                     if(normal)
  917.                     {
  918.                         if(ignore)
  919.                         {      /* strristr() unterscheidet nicht zwischen GROβ und klein */
  920.                             if(sp=strristr(line->string,index,findstr,findstrlen))
  921.                             {
  922.                                 if(inblk)
  923.                                 {
  924.                                     if((int)(sp - line->string)>=line->begcol)
  925.                                         break;
  926.                                 }
  927.                                 else
  928.                                     break;
  929.                             }
  930.                         }
  931.                         else
  932.                         {
  933.                             if(sp=strrstr(line->string,index,findstr,findstrlen))
  934.                             {
  935.                                 if(inblk)
  936.                                 {
  937.                                     if((int)(sp - line->string)>=line->begcol)
  938.                                         break;
  939.                                 }
  940.                                 else
  941.                                     break;
  942.                             }
  943.                         }
  944.                     }
  945.                 }
  946.             }
  947.             if(zeile>=0 && zeile<k &&
  948.                 (inblk?(forward?line!=(*endcut)->next:line!=(*begcut)->prev):1))
  949.             {
  950.                 index=(int)(sp - line->string);
  951.                 if(!replall || ask)
  952.                 {
  953.                     if(forward)
  954.                     {
  955.                         wp->cspos=wp->col=index+findstrlen-wp->wfirst/wp->wscroll;
  956.                         wp->cspos=Wshiftpage(wp,-findstrlen,line->used);
  957.                     }
  958.                     else
  959.                     {
  960.                         wp->cspos=wp->col=index - wp->wfirst/wp->wscroll;
  961.                         wp->cspos=Wshiftpage(wp,-findstrlen,line->used);
  962.                     }
  963.                     if(!inblk)
  964.                     {
  965.                         if(( (*begcut) && !(*endcut)) || /* offenes Blockende     */
  966.                             (!(*begcut) &&  (*endcut)))    /* offener Blockanfang     */
  967.                         {                                            /* nur Cursor setzen     */
  968.                             redraw(wp, line, zeile, FALSE);
  969.                             wp->cspos=wp->col=index-wp->wfirst/wp->wscroll;
  970.                         }
  971.                         else
  972.                         {
  973.                             Wcuroff(wp);
  974.                             redraw(wp, line, zeile, FALSE);
  975.                             *begcut=*endcut=line;
  976.                             (*begcut)->attr|=SELECTED;
  977.                             (*begcut)->begcol=index;
  978.                             (*begcut)->endcol=index+findstrlen;
  979.                             graf_mouse(M_OFF,NULL);
  980.                             mark_line(wp,line,zeile-wp->hfirst/wp->hscroll);
  981.                             graf_mouse(M_ON,NULL);
  982.                             begline=endline=wp->row+wp->hfirst/wp->hscroll;
  983.                             lasthfirst=wp->hfirst;
  984.                             lastwstr=wp->wstr;
  985.                         }
  986.                     }
  987.                     else
  988.                     {
  989.                         redraw(wp, line, zeile, FALSE);
  990.                         wp->cspos=wp->col=index-wp->wfirst/wp->wscroll;
  991.                     }
  992.                 }
  993.                 if(replace)
  994.                 {
  995.                     if(ask)
  996.                     {
  997.                         if(inblk)
  998.                         {
  999.                             graf_mouse(M_OFF,NULL);
  1000.                             Wcursor(wp);                /* Cursor einschalten */
  1001.                             graf_mouse(M_ON,NULL);
  1002.                         }
  1003.                         if(!greped) /* evtl. Wildcard nicht überschreiben */
  1004.                             form_write(replmenu,REPLSTR,replstr,FALSE);
  1005. /*
  1006.                         replmenu->ob_flags|=MOVEABLE; /* kein Windial!!! */
  1007. */                                                          /* oder doch?        */
  1008.                         dialog_positionieren(wp, replmenu);
  1009.                         switch(form_exhndl(replmenu,REPLSTR,FALSE))
  1010.                         {
  1011.                             case REPLABBR:
  1012.                                 replall=FALSE;
  1013.                                 break;
  1014.                             case REPLNEIN:
  1015.                                 replstrlen=1;
  1016.                                 if(!inblk)
  1017.                                 {
  1018.                                     (*begcut)->attr&=~SELECTED;
  1019.                                     (*begcut)->begcol=0;
  1020.                                     (*begcut)->endcol=STRING_LENGTH;
  1021.                                     begline=endline=0L;
  1022.                                     *begcut=*endcut=NULL;
  1023.                                     cut=FALSE;
  1024.                                     redraw(wp, line, zeile, replace);
  1025.                                 }
  1026.                                 break;
  1027.                             case REPLJA:
  1028.                                 form_read(replmenu,REPLSTR,replstr);
  1029.                                 if(greped)
  1030.                                 {
  1031.                                    if((grepcp=strstr(replstr,"\\&"))!=NULL)
  1032.                                    {
  1033.                                       /* Lücke erweitern */
  1034.                                       memmove(&grepcp[findstrlen],
  1035.                                               &grepcp[2],
  1036.                                               strlen(&grepcp[2])+1);
  1037.                                       /* Suchstring wieder einfügen */
  1038.                                       memmove(&grepcp[0],
  1039.                                               sp,
  1040.                                               findstrlen);
  1041.                                    }
  1042.                                 }
  1043.                                 replstrlen=strlen(replstr);
  1044.                                 index=repl_string(line,(int)(sp-line->string),findstrlen,replstr,replstrlen,replall);
  1045.                                 if(index<0)
  1046.                                 {
  1047.                                     switch(index)
  1048.                                     {
  1049.                                         case -1:
  1050.                                               sprintf(alertstr,Afindrep[7],STRING_LENGTH);
  1051.                                             break;
  1052.                                         case -2:
  1053.                                               sprintf(alertstr,Afindrep[16]);
  1054.                                             break;
  1055.                                     }
  1056.                                      form_alert(1,alertstr);
  1057.                                     index=(int)(sp - line->string);
  1058.                                     replall=FALSE;
  1059.                                 }
  1060.                                 else
  1061.                                 {
  1062.                                     if(inblk)
  1063.                                     {
  1064.                                         graf_mouse(M_OFF,NULL);
  1065.                                         Wcursor(wp);      /* ausschalten */
  1066.                                         redraw(wp, line, zeile, replace);
  1067.                                         Wcursor(wp);      /* einschalten */
  1068.                                         graf_mouse(M_ON,NULL);
  1069.                                     }
  1070.                                     else
  1071.                                     {
  1072.                                         line->attr&=~SELECTED;
  1073.                                         line->begcol=0;
  1074.                                         line->endcol=STRING_LENGTH;
  1075.                                         begline=endline=0L;
  1076.                                         *begcut=*endcut=NULL;
  1077.                                         cut=FALSE;
  1078.                                         redraw(wp, line, zeile, replace);
  1079.                                     }
  1080.                                     count++;
  1081.                                 }
  1082.                                 break;
  1083.                         }
  1084.                         if(inblk)
  1085.                         {
  1086.                             graf_mouse(M_OFF,NULL);
  1087.                             Wcursor(wp);    /* ausschalten */
  1088.                             graf_mouse(M_ON,NULL);
  1089.                         }
  1090.                     }
  1091.                     else
  1092.                     {
  1093.                         if(greped)
  1094.                         {
  1095.                             form_read(findmenu,FINDREPL,replstr);
  1096.                            if((grepcp=strstr(replstr,"\\&"))!=NULL)
  1097.                            {
  1098.                               /* Lücke erweitern */
  1099.                               memmove(&grepcp[findstrlen],
  1100.                                       &grepcp[2],
  1101.                                       strlen(&grepcp[2])+1);
  1102.                               /* Suchstring wieder einfügen */
  1103.                               memmove(&grepcp[0],
  1104.                                       sp,
  1105.                                       findstrlen);
  1106.                                 replstrlen=strlen(replstr);
  1107.                            }
  1108.                         }
  1109.                         if((index=repl_string(line,(int)(sp-line->string),findstrlen,replstr,replstrlen,replall))<0)
  1110.                         {
  1111.                             switch(index)
  1112.                             {
  1113.                                 case -1: /* Stringlänge */
  1114.                                       sprintf(alertstr,Afindrep[7],STRING_LENGTH);
  1115.                                     break;
  1116.                                 case -2: /* Out of memory */
  1117.                                       sprintf(alertstr,Afindrep[16]);
  1118.                                     break;
  1119.                             }
  1120.                             form_alert(1,alertstr);
  1121.                             index=(int)(sp - line->string);
  1122.                             replall=FALSE;
  1123.                         }
  1124.                         else
  1125.                             count++;
  1126.                     }
  1127.                 }
  1128.                 if(forward)
  1129.                 {
  1130.                     index += replace ? replstrlen : findstrlen;
  1131.                     if(index > (inblk ? line->endcol-1 : line->used))
  1132.                     {
  1133.                         line=line->next;
  1134.                         if (line)
  1135.                             index=(inblk?line->begcol:0);
  1136.                         else
  1137.                            index=0;
  1138.                         zeile++;
  1139.                     }
  1140.                 }
  1141.                 else
  1142.                 {
  1143.                     index--;
  1144.                     if(index < (inblk ? line->begcol : 0))
  1145.                     {
  1146.                         line=line->prev;
  1147.                         if (line)
  1148.                             index=(inblk?min(line->endcol-1,line->used-1):line->used-1);
  1149.                         else
  1150.                            index=0;
  1151.                         zeile--;
  1152.                     }
  1153.                 }
  1154.             }
  1155.             else
  1156.             {
  1157.                 if(!replace || ask)
  1158.                 {
  1159.                     form_alert(1,Afindrep[8]);
  1160.                     inblk=FALSE; /* Cursor unsichtbar, wenn Block markiert */
  1161.                 }
  1162.                 if(replace && replall)
  1163.                 {
  1164.                     redraw(wp, line, forward?zeile-1:zeile+1, replace);
  1165.                     if(!ask)
  1166.                     {
  1167.                         sprintf(alertstr,Afindrep[9],count);
  1168.                         form_alert(1,alertstr);
  1169.                     }
  1170.                     replall=FALSE;
  1171.                 }
  1172.                 if(forward)
  1173.                 {
  1174.                     if(findmenu[FINDSUCH].ob_state & SELECTED &&
  1175.                         findmenu[FINDNORM].ob_state & SELECTED)
  1176.                     {
  1177.                         findmenu[FINDFORW].ob_state &= ~SELECTED;
  1178.                         findmenu[FINDBACK].ob_state |=  SELECTED;
  1179.                         findmenu[FINDANF ].ob_state &= ~SELECTED;
  1180.                         findmenu[FINDANF ].ob_state |=  DISABLED;
  1181.                         findmenu[FINDMAT ].ob_state |=  DISABLED;
  1182.                         findmenu[FINDGREP].ob_state |=  DISABLED;
  1183.                         forward=FALSE;
  1184.                     }
  1185.                 }
  1186.                 else
  1187.                 {
  1188.                     if(findmenu[FINDSUCH].ob_state & SELECTED &&
  1189.                         findmenu[FINDNORM].ob_state & SELECTED)
  1190.                     {
  1191.                         findmenu[FINDBACK].ob_state &= ~SELECTED;
  1192.                         findmenu[FINDFORW].ob_state |=  SELECTED;
  1193.                         findmenu[FINDANF ].ob_state &= ~DISABLED;
  1194.                         findmenu[FINDMAT ].ob_state &= ~DISABLED;
  1195.                         findmenu[FINDGREP].ob_state &= ~DISABLED;
  1196.                         forward=TRUE;
  1197.                     }
  1198.                 }
  1199.             }
  1200.         }
  1201.         while(replall);
  1202.         if(count)
  1203.         {
  1204.             wp->w_state|=CHANGED; /* es wurde editiert */
  1205.             if(!replall)             /* nicht nötig, weil schon... */
  1206.             {
  1207.                 graf_mouse(M_OFF,0L);
  1208.                 Wredraw(wp,&wp->xwork);
  1209.                 graf_mouse(M_ON,0L);
  1210.             }
  1211.         }
  1212.         graf_mouse(M_OFF,0L);
  1213.         if((!(*begcut) && !(*endcut)) ||
  1214.             ( (*begcut) && !(*endcut)) || /* offenes Blockende */
  1215.             (!(*begcut) &&  (*endcut)))    /* offener Blockanfang */
  1216.             Wcuron(wp);
  1217.         else
  1218.         {
  1219.             if(inblk && !replace)
  1220.                 Wcuron(wp);
  1221.             else
  1222.                 Wcuroff(wp);
  1223.         }
  1224.         Wcursor(wp);  /* einschalten */
  1225.         graf_mouse(M_ON,0L);
  1226. #if OLDTOS
  1227.         graf_mouse(ARROW,0L);
  1228. #endif
  1229.         return(TRUE);
  1230.     }
  1231.     return(FALSE);
  1232. }
  1233.  
  1234. void hndl_blkfind(WINDOW *wp, LINESTRUCT *begcut, LINESTRUCT *endcut, int item)
  1235. {
  1236.     LINESTRUCT *help;
  1237.     int y;
  1238.     if(wp)
  1239.     {
  1240.         if(item==SEARBEG)
  1241.         {
  1242.             for(help=wp->wstr, y=0;
  1243.                  help && y<wp->hwork/wp->hscroll;
  1244.                  help=help->next, y++)
  1245.                 if(help==begcut)
  1246.                 {
  1247.                     graf_mouse(M_OFF,0L);
  1248.                     Wcursor(wp);
  1249.                     wp->cstr=help;
  1250.                     wp->cspos=wp->col=help->begcol-wp->wfirst/wp->wscroll;
  1251. wp->cspos=Wshiftpage(wp,0,wp->cstr->used);
  1252.                     Wcursor(wp);
  1253.                     graf_mouse(M_ON,0L);
  1254.                     return;
  1255.                 }
  1256.             if(begcut)
  1257.             {
  1258.                 wp->hfirst=0;
  1259.                 for(help=wp->fstr; help!=begcut; help=help->next)
  1260.                     wp->hfirst+=wp->hscroll;
  1261.                 wp->wstr=wp->cstr=help;
  1262.                 wp->cspos=wp->col=help->begcol-wp->wfirst/wp->wscroll;
  1263. wp->cspos=Wshiftpage(wp,0,wp->cstr->used);
  1264.                 for(y=0; y<POSITION_OFFSET  && wp->wstr->prev;
  1265.                      y++, wp->wstr=wp->wstr->prev)
  1266.                     wp->hfirst-=wp->hscroll;
  1267.                 adjust_best_position(wp); /* eventuell unten anpassen */
  1268.                 graf_mouse(M_OFF,0L);
  1269.                 Wcursor(wp);
  1270.                 Wredraw(wp,&wp->xwork);
  1271.                 Wcursor(wp);
  1272.                 graf_mouse(M_ON,0L);
  1273.             }
  1274.         }
  1275.         else
  1276.         {
  1277.             for(help=wp->wstr, y=0;
  1278.                  help && y<wp->hwork/wp->hscroll;
  1279.                  help=help->next, y++)
  1280.                 if(help==endcut)
  1281.                 {
  1282.                     graf_mouse(M_OFF,0L);
  1283.                     Wcursor(wp);
  1284.                     wp->cstr=help;
  1285.                     wp->cspos=wp->col=help->endcol-wp->wfirst/wp->wscroll;
  1286. wp->cspos=Wshiftpage(wp,0,wp->cstr->used);
  1287.                     Wcursor(wp);
  1288.                     graf_mouse(M_ON,0L);
  1289.                     return;
  1290.                 }
  1291.             if(endcut)
  1292.             {
  1293.                  if(begcut==endcut)
  1294.                  {
  1295.                      graf_mouse(M_OFF,0L);
  1296.                      Wcursor(wp);
  1297.                      wp->col+=endcut->endcol;
  1298.                      wp->cspos=wp->col;
  1299. wp->cspos=Wshiftpage(wp,0,wp->cstr->used);
  1300.                      Wcursor(wp);
  1301.                      graf_mouse(M_ON,0L);
  1302.                      return;
  1303.                  }
  1304.                  wp->hfirst=0;
  1305.                  for(help=wp->fstr; help!=endcut; help=help->next)
  1306.                      wp->hfirst+=wp->hscroll;
  1307.                  wp->wstr=wp->cstr=help;
  1308.                  wp->cspos=wp->col=endcut->endcol-wp->wfirst/wp->wscroll;
  1309. wp->cspos=Wshiftpage(wp,0,wp->cstr->used);
  1310.                  for(y=0; y<POSITION_OFFSET  && wp->wstr->prev;
  1311.                       y++, wp->wstr=wp->wstr->prev)
  1312.                      wp->hfirst-=wp->hscroll;
  1313.                  adjust_best_position(wp); /* eventuell unten anpassen */
  1314.                  graf_mouse(M_OFF,0L);
  1315.                  Wcursor(wp);
  1316.                  Wredraw(wp,&wp->xwork);
  1317.                  Wcursor(wp);
  1318.                  graf_mouse(M_ON,0L);
  1319.             }
  1320.         }
  1321.     }
  1322. }
  1323.  
  1324. int iserrfile(WINDOW *wp)
  1325. {
  1326.     register int k;
  1327.     if(wp)
  1328.     {
  1329.         k=strlen(wp->name);
  1330.         if(          wp->name[k-4] =='.' &&
  1331.             toupper(wp->name[k-3])=='E' &&
  1332.             toupper(wp->name[k-2])=='R' &&
  1333.             toupper(wp->name[k-1])=='R')
  1334.             return(TRUE);
  1335.         if(          wp->name[k-4] =='.' &&
  1336.             toupper(wp->name[k-3])=='L' &&
  1337.             toupper(wp->name[k-2])=='O' &&
  1338.             toupper(wp->name[k-1])=='G')
  1339.             return(TRUE);
  1340.     }
  1341.     return(FALSE);
  1342. }
  1343.  
  1344. int isregfile(WINDOW *wp)
  1345. {
  1346.     register int k;
  1347.     if(wp)
  1348.     {
  1349.         k=strlen(wp->name);
  1350.         if(        wp->name[k-4] =='.' && 
  1351.            toupper(wp->name[k-3])=='R' &&
  1352.             toupper(wp->name[k-2])=='E' && 
  1353.             toupper(wp->name[k-1])=='G')
  1354.             return(TRUE);
  1355.     }
  1356.     return(FALSE);
  1357. }
  1358.  
  1359. int hndl_goto(WINDOW *wp, OBJECT *tree, long line)
  1360. {
  1361.   register LINESTRUCT *help;
  1362.   register long i,k,newpos;
  1363.   char string[10];
  1364.   
  1365.   extern LINESTRUCT *begcut,*endcut;
  1366.  
  1367.   if(wp)
  1368.   {
  1369.       if(tree)
  1370.       {
  1371.           sprintf(string,"%ld",wp->hfirst/wp->hscroll+wp->row+1);
  1372.           form_write(tree,GOTOLINE,string,FALSE);
  1373.           if(form_exhndl(tree,GOTOLINE,FALSE)==GOTOABBR)
  1374.               return(FALSE);
  1375.           form_read(tree,GOTOLINE,string);
  1376.           line=atol(string);
  1377.       }
  1378.       k=wp->hsize/wp->hscroll;
  1379.      i=line-1;
  1380.      if(TRUE)
  1381.       {
  1382.           if(i<0)
  1383.               i=0;
  1384.           if(i>(k-1))
  1385.               i=k-1;
  1386.           if(i == wp->row + wp->hfirst/wp->hscroll)
  1387.               return(TRUE);
  1388.           for(k=0, help=wp->fstr; k<i && help->next; k++, help=help->next)
  1389.               ;
  1390.           wp->wstr=wp->cstr=help;
  1391.           for(k=0; k<POSITION_OFFSET  && wp->wstr->prev; k++, i--, wp->wstr=wp->wstr->prev)
  1392.               ;
  1393.           wp->hfirst=i*wp->hscroll;
  1394.           adjust_best_position(wp); /* eventuell unten anpassen */
  1395.           graf_mouse(M_OFF,0L);
  1396.           Wcursor(wp);
  1397. /* Zeile gleich markieren, wenn nichts markiert oder ausgeschnitten ist */
  1398.           if(/*line==-1 &&*/ tree && !begcut && !endcut)
  1399.           {
  1400.               if(cut)                /* gibt es erst noch müll zu löschen */
  1401.                   free_blk(wp,begcut);
  1402.               else
  1403.                   hide_blk(wp,begcut,endcut);
  1404.               begcut=endcut=wp->cstr;
  1405.               begcut->attr|=SELECTED;
  1406.               begcut->begcol=0;
  1407.               begcut->endcol=STRING_LENGTH;
  1408.               begline=wp->row+wp->hfirst/wp->hscroll;
  1409.               endline=begline+1;
  1410.               wp->cspos=wp->col=0;
  1411.               lasthfirst=wp->hfirst;
  1412.               lastwstr=wp->wstr;
  1413.               Wcuroff(wp);
  1414.           }
  1415.           Wredraw(wp,&wp->xwork);
  1416.           Wcursor(wp);
  1417.           graf_mouse(M_ON,0L);
  1418.       }
  1419. /*
  1420.       else
  1421.           form_alert(1,Afindrep[10]);
  1422. */
  1423.   }
  1424.   return(FALSE);
  1425. }
  1426.  
  1427. hndl_page(WINDOW *wp, OBJECT *tree, long line)
  1428. {
  1429.     long zeile;
  1430.     char string[10];
  1431.     
  1432.     if(wp)
  1433.     {
  1434.       form_write(tree,ROOT+2,SUCHE_SEITE,FALSE);
  1435.       strcpy((char* )tree[GOTOLINE-1].ob_spec.index,SEITE_____);
  1436.       sprintf(string,"%ld",(wp->row+wp->hfirst/wp->hscroll)/zz+1);
  1437.       form_write(tree,GOTOLINE,string,FALSE);
  1438.       if(form_exhndl(tree,GOTOLINE,FALSE)==GOTOABBR)
  1439.       {
  1440.           form_write(tree,ROOT+2,SUCHE_ZEILE,FALSE);
  1441.           strcpy((char *)tree[GOTOLINE-1].ob_spec.index,ZEILE_____);
  1442.           return;
  1443.       }
  1444.       form_write(tree,ROOT+2,SUCHE_ZEILE,FALSE);
  1445.       strcpy((char *)tree[GOTOLINE-1].ob_spec.index,ZEILE_____);
  1446.       form_read(tree,GOTOLINE,string);
  1447.       zeile=(atol(string)-1)*zz+1;
  1448.       if(zeile<1)
  1449.           zeile=1;
  1450.       hndl_goto(wp,NULL,zeile);
  1451.     }
  1452. }
  1453.  
  1454. typedef struct
  1455. {
  1456.     long absrow,abscol;
  1457.     LINESTRUCT *line;
  1458.     char *string;
  1459.     WINDOW *wp;
  1460. } LINEMARK;
  1461.  
  1462. void gotomark(WINDOW *wp, LINEMARK *mark)
  1463. {
  1464.   register LINESTRUCT *help;
  1465.   register long i,k,newpos;
  1466.   char zeile[10];
  1467.  
  1468.   if(wp)
  1469.   {
  1470.       if(wp!=mark->wp)
  1471.       {
  1472.           if(Wopen(mark->wp)) /* Fensterwechsel */
  1473.               wp=mark->wp;
  1474.           else
  1475.               return;             /* Fenster existiert nicht mehr */
  1476.       }
  1477.       for(k=0, help=wp->fstr; help; k++, help=help->next)
  1478.           if(help==(LINESTRUCT *)mark->line && help->string==(char *)mark->string)
  1479.               if(mark->abscol > help->used)
  1480.               {
  1481.                   for(; help; k++, help=help->next)
  1482.                       if(mark->abscol <= help->used)
  1483.                       {
  1484.                           goto WEITER; /* kein break möglich */
  1485.                       }
  1486.               }
  1487.               else
  1488.                   break;
  1489. WEITER:
  1490.       if(help)
  1491.           sprintf(zeile,"%ld",k+1);
  1492.       else
  1493.           sprintf(zeile,"%ld",mark->absrow+1);
  1494.  
  1495.       if(hndl_goto(wp,NULL/*gotomenu*/,atol(zeile)))  /* redraw hinterherschicken */
  1496.       {
  1497.           graf_mouse(M_OFF,0L);
  1498.           Wcursor(wp);
  1499.           Wredraw(wp,&wp->xwork);
  1500.           Wcursor(wp);
  1501.           graf_mouse(M_ON,0L);
  1502.       }
  1503.       graf_mouse(M_OFF,0L);
  1504.       Wcursor(wp);
  1505.       wp->col=wp->cspos=mark->abscol-wp->wfirst/wp->wscroll;
  1506. wp->cspos=Wshiftpage(wp,0,wp->cstr->used);
  1507.       Wcursor(wp);
  1508.       graf_mouse(M_ON,0L);
  1509.   }
  1510. }
  1511.  
  1512. int inw(char c) /* In Word */
  1513. {                             /* ^  ^     */
  1514.     return( ! (c && !isspace(c) && (isalnum(c) || isgerman(c))));
  1515. }
  1516.  
  1517. int find_next_letter(char *str, int col) /* für control-cursor zum nächsten Wort */
  1518. {
  1519.     register int i,len;
  1520.  
  1521.     if(col==-1) /* Sonderfall wg. Zeilenwechsel */
  1522.     {
  1523.         if(!isspace(str[0]))
  1524.             return(0);
  1525.         col=0;
  1526.     }
  1527.     len=strlen(str);
  1528.     if(inw(str[col]))
  1529.     {
  1530.         for(i=col; i<len; i++)
  1531.             if(!inw(str[i]))
  1532.                 break;
  1533.         return(i);
  1534.     }
  1535.     else
  1536.     {
  1537.         for(i=col; i<len; i++)
  1538.             if(inw(str[i]))
  1539.                 break;
  1540.         for(i     ; i<len; i++)
  1541.             if(!inw(str[i]))
  1542.                 break;
  1543.         return(i);
  1544.     }
  1545. }
  1546.  
  1547. int find_prev_letter(char *str, int col) /* von Wort zu Wort mit CONTROL+CURSOR */
  1548. {
  1549.     register int i;
  1550.     if(!str[col])
  1551.     {
  1552.         if(inw(str[col-1]))
  1553.         {
  1554.             for(i=col; i>=0; i--)
  1555.                 if(inw(str[i]))
  1556.                     break;
  1557.             for(i     ; i>=0; i--)
  1558.                 if(!inw(str[i]))
  1559.                     break;
  1560.             for(i     ; i>=0; i--)
  1561.                 if(inw(str[i]))
  1562.                     break;
  1563.         }
  1564.         else
  1565.         {
  1566.             for(i=col; i>=0; i--)
  1567.                 if(str[i] && inw(str[i]))
  1568.                 {
  1569.                     break;
  1570.                 }
  1571.         }
  1572.         return(i+1);
  1573.     }
  1574.     if(inw(str[col]))
  1575.     {
  1576.         for(i=col; i>=0; i--)
  1577.             if(!inw(str[i]))
  1578.                 break;
  1579.         for(i     ; i>=0; i--)
  1580.             if(inw(str[i]))
  1581.                 break;
  1582.     }
  1583.     else
  1584.     {
  1585.         if(inw(str[col-1]))
  1586.         {
  1587.             for(i=col; i>=0; i--)
  1588.                 if(inw(str[i]))
  1589.                     break;
  1590.             for(i    ; i>=0; i--)
  1591.                 if(!inw(str[i]))
  1592.                     break;
  1593.             for(i    ; i>=0; i--)
  1594.                 if(inw(str[i]))
  1595.                     break;
  1596.         }
  1597.         else
  1598.         {
  1599.             for(i=col; i>=0; i--)
  1600.                 if(inw(str[i]))
  1601.                     break;
  1602.         }
  1603.     }
  1604.     return(i+1);
  1605. }
  1606.  
  1607. void _strntog(char *str, int n)
  1608. {
  1609.     while(str && *str && n--)
  1610.     {
  1611.         if(__isupper(*str))
  1612.             *str=__tolower(*str);
  1613.         else
  1614.             *str=__toupper(*str);
  1615.         str++;
  1616.     }
  1617. }
  1618.  
  1619. void _strnupr(char *str, int n)
  1620. {
  1621.     while(str && *str && n--)
  1622.     {
  1623.         *str=__toupper(*str);
  1624.         str++;
  1625.     }
  1626. }
  1627.  
  1628. void _strnlwr(char *str, int n)
  1629. {
  1630.     while(str && *str && n--)
  1631.     {
  1632.         *str=__tolower(*str);
  1633.         str++;
  1634.     }
  1635. }
  1636.  
  1637. void _strncaps(char *str, int n)
  1638. {
  1639.     register int i;
  1640.     if(!str)
  1641.         return;
  1642.     if(*str)
  1643.         *str=__toupper(*str);
  1644.     i=find_next_letter(str,0);
  1645.     while(str[i] && i<n)
  1646.     {
  1647.         str[i]=__toupper(str[i]);
  1648.         i=find_next_letter(str,i);
  1649.     }
  1650. }
  1651.  
  1652. char *_findword(char *linebeg, char *pos, int *len)
  1653. {
  1654.     char *cp;
  1655.  
  1656.     if(isspace(*pos)) /* raus bei Blank */
  1657.         return(NULL);
  1658.         
  1659.     for(pos; !isspace(*pos) && pos>=linebeg; pos--)
  1660.         ;
  1661.     pos++;
  1662.     cp=strchr(pos,' ');
  1663.     if(!cp) /* Zeilenende?, dann null suchen */
  1664.         cp=strchr(pos,0);
  1665.     if(cp)
  1666.     {
  1667.         *len=(int)((long)cp-(long)pos);
  1668.         return(pos);
  1669.     }
  1670.     else
  1671.         return(NULL);
  1672. }
  1673.  
  1674. void changeletters(WINDOW *wp, LINESTRUCT *beg, LINESTRUCT *end, int mode)
  1675. {
  1676.     int col,y1,y2,len;
  1677.     LINESTRUCT *line;
  1678.     GRECT rect;
  1679.     char *cp;
  1680.  
  1681.     if(wp)
  1682.     {
  1683.         if(!beg && !end)
  1684.         {                                    /* Wort suchen und als markieren Block */
  1685.             cp=_findword(wp->cstr->string, &wp->cstr->string[wp->col+wp->wfirst/wp->wscroll], &len);
  1686.             col=(int)((long)cp-(long)wp->cstr->string)-wp->wfirst/wp->wscroll;
  1687.             rect.g_x=wp->xwork+col*wp->wscroll;
  1688.             rect.g_y=wp->ywork+wp->row*wp->hscroll;
  1689.             rect.g_w=len*wp->wscroll;
  1690.             rect.g_h=wp->hscroll;
  1691.             switch(mode)
  1692.             {
  1693.                 case EDITTOGL:
  1694.                     _strntog(&wp->cstr->string[wp->col+wp->wfirst/wp->wscroll],1);
  1695.                     rect.g_x=wp->xwork+wp->col*wp->wscroll;
  1696.                     rect.g_w=wp->wscroll;
  1697.                     break;
  1698.                 case EDITBIG:
  1699.                     _strnupr(cp,len);
  1700.                     break;
  1701.                 case EDITSMAL:
  1702.                     _strnlwr(cp,len);
  1703.                     break;
  1704.                 case EDITCAPS:
  1705.                     _strnlwr(cp,len);
  1706.                     _strncaps(cp,len);
  1707.                     break;
  1708.             }
  1709.             wp->w_state|=CHANGED;
  1710.             graf_mouse(M_OFF,0L);
  1711.             Wcursor(wp);
  1712.             Wredraw(wp,&rect);
  1713.             if(mode==EDITTOGL) /* gleich ein Zeichen weiterrücken */
  1714.             {
  1715.                 wp->col++;
  1716.                 wp->cspos++;
  1717.             }
  1718.             Wcuron(wp);
  1719.             Wcursor(wp);
  1720. /*
  1721.             graf_mouse(M_ON,0L);
  1722. */
  1723.             return;
  1724.         }
  1725.         if(beg && end)
  1726.         {
  1727.             graf_mouse(BUSY_BEE,NULL);
  1728.             for(line=beg; line && line!=end->next; line=line->next)
  1729.             {
  1730.                 if(line->begcol<line->used)
  1731.                     switch(mode)
  1732.                     {
  1733.                         case EDITTOGL:
  1734.                             _strntog(&line->string[line->begcol],line->endcol-line->begcol);
  1735.                             break;
  1736.                         case EDITBIG:
  1737.                             _strnupr(&line->string[line->begcol],line->endcol-line->begcol);
  1738.                             break;
  1739.                         case EDITSMAL:
  1740.                             _strnlwr(&line->string[line->begcol],line->endcol-line->begcol);
  1741.                             break;
  1742.                         case EDITCAPS:
  1743.                             _strnlwr(&line->string[line->begcol],line->endcol-line->begcol);
  1744.                             _strncaps(&line->string[line->begcol],line->endcol-line->begcol);
  1745.                             break;
  1746.                     }
  1747.             }
  1748.             wp->w_state|=CHANGED;
  1749.             for(line=wp->wstr,y1=wp->ywork;
  1750.                  line && y1<(wp->ywork+wp->hwork-1);
  1751.                  line=line->next, y1+=wp->hscroll)
  1752.                 if(line->attr & SELECTED)
  1753.                     break;
  1754.             for(y2=y1;
  1755.                  line && y2<(wp->ywork+wp->hwork-1);
  1756.                  line=line->next, y2+=wp->hscroll)
  1757.                 if(!(line->attr&SELECTED))
  1758.                     break;
  1759.             rect.g_x=wp->xwork;
  1760.             rect.g_y=y1;
  1761.             rect.g_w=wp->wwork;
  1762.             rect.g_h=y2-y1;
  1763.             graf_mouse(M_OFF,0L);
  1764.             Wcursor(wp);
  1765.             Wredraw(wp,&rect);
  1766.             Wcursor(wp);
  1767. /*
  1768.             graf_mouse(M_ON,0L);
  1769. */
  1770.             graf_mouse(ARROW,NULL);
  1771.         }
  1772.     }
  1773. }
  1774.  
  1775. void gotobraceerror(WINDOW *wp, long line, int col, int diff, char Aerror[])
  1776. {
  1777.     sprintf(alertstr,Aerror,diff);
  1778.     form_alert(1,alertstr);
  1779.     hndl_goto(wp,NULL,line+1); /* Fehlerstelle */
  1780.     graf_mouse(M_OFF,0L); /* Cursor positionieren */
  1781.     Wcursor(wp);
  1782.     wp->cspos=wp->col=col-wp->wfirst/wp->wscroll;
  1783.     wp->cspos=Wshiftpage(wp,0,wp->cstr->used);
  1784.     Wcursor(wp);
  1785.     graf_mouse(M_ON,0L); /* Cursor positionieren */
  1786. }
  1787.  
  1788. int check_braces(OBJECT *tree, WINDOW *wp, LINESTRUCT *begcut, LINESTRUCT *endcut)
  1789. {
  1790.     int eckig=0, rund=0, geschweift=0, spitz=0, pkom=0, ckom=0;
  1791.     int i,ret,a,b,c,d,e,f,g,h,j,k,l,exit_obj,stop=FALSE;
  1792.     register LINESTRUCT *help;
  1793.     long line;
  1794.     char freebeg[11], freeend[11];
  1795.  
  1796.     char free1beg[11], free1end[11];
  1797.     char free2beg[11], free2end[11];
  1798.     char free3beg[11], free3end[11];
  1799.     char free4beg[11], free4end[11];
  1800.     char free5beg[11], free5end[11];
  1801.     
  1802.     if(wp)
  1803.     {
  1804.         a=tree[CBRACE].ob_state;
  1805.         b=tree[SBRACE].ob_state;
  1806.         c=tree[RBRACE].ob_state;
  1807.         d=tree[PBRACE].ob_state;
  1808.         e=tree[PKOMBRAC].ob_state;
  1809.         f=tree[CKOMBRAC].ob_state;
  1810.         g=tree[FREE1BRACE].ob_state;
  1811.         h=tree[FREE2BRACE].ob_state;
  1812.         j=tree[FREE3BRACE].ob_state;
  1813.         k=tree[FREE4BRACE].ob_state;
  1814.         l=tree[FREE5BRACE].ob_state;
  1815.         form_read(tree,FREE1BEG,free1beg);
  1816.         form_read(tree,FREE1END,free1end);
  1817.         form_read(tree,FREE2BEG,free2beg);
  1818.         form_read(tree,FREE2END,free2end);
  1819.         form_read(tree,FREE3BEG,free3beg);
  1820.         form_read(tree,FREE3END,free3end);
  1821.         form_read(tree,FREE4BEG,free4beg);
  1822.         form_read(tree,FREE4END,free4end);
  1823.         form_read(tree,FREE5BEG,free5beg);
  1824.         form_read(tree,FREE5END,free5end);
  1825.       
  1826.         form_exopen(tree,0);
  1827.         do
  1828.         {
  1829.             exit_obj=form_exdo(tree,0);
  1830.             if(exit_obj==BRACHELP)
  1831.             {
  1832.                 form_alert(1,Afindrep[11]);
  1833.                 objc_change(tree,exit_obj,0,tree->ob_x,tree->ob_y,tree->ob_width,tree->ob_height,tree[exit_obj].ob_state&~SELECTED,TRUE);
  1834.             }
  1835.         }
  1836.         while(exit_obj==BRACHELP);
  1837.         form_exclose(tree,exit_obj,0);
  1838.  
  1839.         if(exit_obj==BRACOK)
  1840.         {
  1841. #if OLDTOS
  1842.             graf_mouse(BUSY_BEE,NULL);
  1843. #endif
  1844.          line=(begcut && endcut)?begline:0L;
  1845.             for(help=begcut?begcut:wp->fstr; endcut?help!=endcut->next:help; help=help->next,line++)
  1846.             {
  1847.                 for(i=0; i<help->used; i++)
  1848.                 {
  1849.                     switch(help->string[i])
  1850.                     {
  1851.                         case '(':
  1852.                             rund++;
  1853.                             if(help->string[i+1]=='*')
  1854.                                 pkom++; /* Pascal Kommentar */
  1855.                             break;
  1856.                         case ')':
  1857.                             rund--;
  1858.                             if(help->string[i-1]=='*')
  1859.                                 pkom--; /* Pascal Kommentar */
  1860.                      if(rund<0)
  1861.                         stop=TRUE;
  1862.                             break;
  1863.                         case '/':
  1864.                             if(help->string[i+1]=='*')
  1865.                                 ckom++; /* C Kommentar */
  1866.                             if(help->string[i-1]=='*')
  1867.                                 ckom--; /* C Kommentar */
  1868.                      if(ckom<0)
  1869.                         stop=TRUE;
  1870.                             break;                            
  1871.                         case '{':
  1872.                             geschweift++;
  1873.                             break;
  1874.                         case '}':
  1875.                             geschweift--;
  1876.                      if(geschweift<0)
  1877.                         stop=TRUE;
  1878.                             break;
  1879.                         case '[':
  1880.                             eckig++;
  1881.                             break;
  1882.                         case ']':
  1883.                             eckig--;
  1884.                      if(eckig<0)
  1885.                         stop=TRUE;
  1886.                             break;
  1887.                         case '<':
  1888.                             spitz++;
  1889.                             break;
  1890.                         case '>':
  1891.                             spitz--;
  1892.                      if(spitz<0)
  1893.                         stop=TRUE;
  1894.                             break;
  1895.                     }
  1896.                     if(stop)
  1897.                        break;
  1898.                 }
  1899.                 if(stop)
  1900.                    break;
  1901.             }
  1902. #if OLDTOS
  1903.             graf_mouse(ARROW,NULL);
  1904. #endif
  1905.             if((tree[CBRACE].ob_state & SELECTED) && geschweift)
  1906.             {
  1907.             gotobraceerror(wp, line, i, geschweift, Afindrep[12]);
  1908.             }
  1909.             if((tree[SBRACE].ob_state & SELECTED) && eckig)
  1910.             {
  1911.             gotobraceerror(wp, line, i, eckig, Afindrep[13]);
  1912.             }
  1913.             if((tree[RBRACE].ob_state & SELECTED) && rund)
  1914.             {
  1915.             gotobraceerror(wp, line, i, rund, Afindrep[14]);
  1916.             }
  1917.             if((tree[PBRACE].ob_state & SELECTED) && spitz)
  1918.             {
  1919.             gotobraceerror(wp, line, i, spitz, Afindrep[15]);
  1920.             }
  1921.             if((tree[PKOMBRAC].ob_state & SELECTED) && pkom)
  1922.             {
  1923.             gotobraceerror(wp, line, i, pkom, Afindrep[17]);
  1924.             }
  1925.             if((tree[CKOMBRAC].ob_state & SELECTED) && ckom)
  1926.             {
  1927.             gotobraceerror(wp, line, i, ckom, Afindrep[18]);
  1928.             }
  1929.  
  1930.           for(i=FREE1BRACE; i<=FREE5BRACE; i+=3)
  1931.                 if((tree[i].ob_state & SELECTED))
  1932.                 {  /* freie Suchmuster */
  1933.                 form_read(tree,i+1,freebeg);
  1934.                 form_read(tree,i+2,freeend);
  1935.                     Afindrep[19][12]=(char)((i-FREE1BRACE)/3+'1');
  1936.                     Afindrep[20][12]=(char)((i-FREE1BRACE)/3+'1');
  1937.                     ret=Wirth(wp,begcut,endcut,freebeg,freeend,&line,&a);
  1938.                     if(ret>0)
  1939.                     {
  1940.                   gotobraceerror(wp, line, a, ret, Afindrep[19]);
  1941.                     }
  1942.                     if(ret<0)
  1943.                     {
  1944.                   gotobraceerror(wp, line, a, abs(ret), Afindrep[20]);
  1945.                     }
  1946.                 }
  1947.         }
  1948.         else
  1949.         {
  1950.             tree[CBRACE].ob_state=a;
  1951.             tree[SBRACE].ob_state=b;
  1952.             tree[RBRACE].ob_state=c;
  1953.             tree[PBRACE].ob_state=d;
  1954.               tree[PKOMBRAC].ob_state=e;
  1955.             tree[CKOMBRAC].ob_state=f;
  1956.             tree[FREE1BRACE].ob_state=g;
  1957.             tree[FREE2BRACE].ob_state=h;
  1958.             tree[FREE3BRACE].ob_state=j;
  1959.             tree[FREE4BRACE].ob_state=k;
  1960.             tree[FREE5BRACE].ob_state=l;
  1961.             form_write(tree,FREE1BEG,free1beg,FALSE);
  1962.             form_write(tree,FREE1END,free1end,FALSE);
  1963.             form_write(tree,FREE2BEG,free2beg,FALSE);
  1964.             form_write(tree,FREE2END,free2end,FALSE);
  1965.             form_write(tree,FREE3BEG,free3beg,FALSE);
  1966.             form_write(tree,FREE3END,free3end,FALSE);
  1967.             form_write(tree,FREE4BEG,free4beg,FALSE);
  1968.             form_write(tree,FREE4END,free4end,FALSE);
  1969.             form_write(tree,FREE5BEG,free5beg,FALSE);
  1970.             form_write(tree,FREE5END,free5end,FALSE);
  1971.         }
  1972.     }
  1973. }
  1974.